home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / bytecode.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-05-14  |  11.3 KB  |  296 lines
  1. // $Id: bytecode.h,v 1.4 1999/03/09 14:37:15 shields Exp $
  2. //
  3. // License Agreement available at the following URL:
  4. // http://www.ibm.com/research/jikes.
  5. // Copyright (C) 1996, 1998, International Business Machines Corporation
  6. // and others.  All Rights Reserved.
  7. // You must accept the terms of that agreement to use this software.
  8.  
  9. //
  10. #ifndef bytecode_INCLUDED
  11. #define bytecode_INCLUDED
  12.  
  13. #include <stdio.h>
  14. #include "tuple.h"
  15. #include "ast.h"
  16. #include "class.h"
  17. #include "option.h"
  18. #include "long.h"
  19. #include "op.h"
  20.  
  21. class TypeSymbol;
  22. class Control;
  23. class Semantic;
  24.  
  25. class LabelUse
  26. {
  27. public:
  28.     int use_length;    // length of use (2 or 4 bytes)
  29.     int op_offset;    // length of use from opcode starting instruction
  30.     int use_offset;    // offset in code stream of use
  31.  
  32.     LabelUse() : use_length(0),op_offset(0), use_offset(0) {}
  33.  
  34.     LabelUse(int _length, int _op_offset, int _use) : 
  35.         use_length(_length),op_offset(_op_offset),use_offset(_use) {}
  36. };
  37.  
  38. class Label
  39. {
  40. public:
  41.      int    defined; // boolean, set when value is known
  42.      int    definition; // offset of definition point of label
  43.      Tuple<LabelUse> uses;
  44.  
  45.      Label() : defined(0), definition(0) {}
  46. };
  47.  
  48. class ByteCode : public ClassFile, public StringConstant
  49. {
  50.     public:
  51.     Control& this_control;
  52.     Semantic& this_semantic;
  53.     int class_id;
  54. //    int bytes;                          // number of bytes written to file (so far)
  55.  
  56. // Many java virtual machines, notably Sun's JDK 1.*, don't properly
  57. // handle the case where non-final static fields are initialized
  58. // using the Constant attribute, even though the documentation says
  59. // that this should be done. Define initialize_statics_in_clinit
  60. // to get this behavior to initialize such fields in clinit; otherwise
  61. // fields are initialized using the Constant attribute.
  62.     int initialize_statics_in_clinit;
  63.     
  64.     int null_constructor_seen;    // set if user supplied null constructor
  65.         // if not set, we have to supply null constructor
  66.     int line_number;
  67.     int last_label_pc;  // pc for last (closest to end) label
  68.     int last_op_pc;    // pc of last operation emitted
  69.     int last_op_nop; // set if last operation was NOP.
  70.     int this_block_depth; // depth of current block
  71.     Code_attribute * code_attribute;     // code for current method/??
  72.     int stack_depth;        // current stack depth;
  73.     LineNumberTable_attribute * line_number_table_attribute;
  74.     LocalVariableTable_attribute * local_variable_table_attribute;
  75. //    Synthetic_attribute * synthetic_attribute;
  76.     InnerClasses_attribute * inner_classes_attribute;
  77.     MethodSymbol * class_literal_method;
  78.  
  79. #define METHOD_CLONE 0
  80. #define METHOD_CLONE_GETMESSAGE 1
  81. #define METHOD_CLONE_INIT    2
  82. #define METHOD_STRINGBUFFER_TOSTRING     3
  83. #define METHOD_STRINGBUFFER_INIT    4
  84. #define METHOD_STRINGBUFFER_APPENDCHARARRAY 5    
  85. #define METHOD_STRINGBUFFER_APPENDCHAR 6        
  86. #define METHOD_STRINGBUFFER_APPENDBOOLEAN 7        
  87. #define METHOD_STRINGBUFFER_APPENDINT    8        
  88. #define METHOD_STRINGBUFFER_APPENDLONG    9        
  89. #define METHOD_STRINGBUFFER_APPENDFLOAT    10        
  90. #define METHOD_STRINGBUFFER_APPENDDOUBLE    11        
  91. #define METHOD_STRINGBUFFER_APPENDSTRING    12    
  92. #define METHOD_STRINGBUFFER_APPENDOBJECT    13
  93. #define METHOD_NUMBER 14  
  94.     
  95.     int registered_methods[METHOD_NUMBER];
  96.     
  97.     u2 name_StringNull;
  98.  
  99.     int max_block_depth;
  100.     int last_parameter_index; // set to local variable index of last parameter
  101.     Label * begin_labels;
  102.     Label * break_labels;
  103.     Label * continue_labels;
  104.     Label * final_labels;
  105.     Label * monitor_labels;
  106.     Label * test_labels;
  107.     int * has_finally_clause;
  108.     int * is_synchronized;
  109.     int   synchronized_blocks; // number of outstanding synchronized blocks
  110.     int   finally_blocks; // number of outstanding synchronized blocks
  111.     BlockSymbol ** block_symbols; // block symbols for current block
  112.     int block_depth;                  // need to reset at start of each method
  113.     TypeSymbol * method_type;    // return type of method being compiled
  114.  
  115. void chaos(char *msg);   // called when can't proceed
  116.  
  117.  
  118. void    ProcessAbruptExit(int);
  119. void    CompleteLabel(Label& lab);
  120. void    DefineLabel(Label& lab);
  121. int     IsLabelUsed(Label& lab);
  122. void    UseLabel(Label & lab,int length, int op_offset);
  123.  
  124. // methods to determine type
  125. int     IsLocal(AstExpression *);
  126. int     IsNull(AstExpression *p);
  127. int     IsReferenceType(TypeSymbol *p);
  128. int     IsDefaultValue(AstExpression *p);
  129. int     IsZero(AstExpression *p);
  130. int     GetLHSKind(AstExpression *, MethodSymbol *);
  131. int     GetTypeWords(TypeSymbol *);
  132.  
  133. // methods to load and store values
  134. void    LoadLocalVariable(VariableSymbol *);
  135. void    LoadLocal(int varno, TypeSymbol * type);
  136. void    StoreLocalVariable(VariableSymbol *);
  137. void    StoreLocal(int varno, TypeSymbol * type);
  138. int     GetConstant(LiteralValue *, TypeSymbol *);
  139. int     LoadConstant(AstExpression *);
  140. int     LoadLiteral(LiteralValue *,TypeSymbol *);
  141. void    LoadReference(AstExpression *);
  142. void    LoadShort(int val);
  143. void    LoadInteger(int val);
  144. int     LoadSimple(int,AstExpression *);
  145. int     LoadArrayElement(TypeSymbol * type);
  146. void    StoreArrayElement(TypeSymbol * type);
  147. void    StoreField(AstExpression *);
  148. void    StoreSimple(int,AstExpression *);
  149.  
  150. // These methods build entries in the constant pool.
  151. u2      BuildDouble(IEEEdouble val);
  152. u2      BuildFieldref(u2 cl_index, u2 nt_index);
  153. u2      BuildFloat(IEEEfloat val);
  154. u2      BuildInteger(int val);
  155. u2      BuildInterfaceMethodref(u2 cl_index, u2 nt_index);
  156. u2      BuildLong(LongInt val);
  157. u2      BuildMethodref(u2 cl_index, u2 nt_index);
  158. u2      BuildNameAndType(u2 name, u2 type);
  159.  
  160. // make entry in constant pool from wchar string and return its index.
  161. u2      BuildString(u2 si);
  162. u2      BuildUtf8(char *name,int length);
  163.  
  164. // unlike most methods, which always build a new entry, the
  165. // 'register' methods only build a new entry for a literal if one has net
  166. // yet been built.
  167. u2      RegisterClass(Utf8LiteralValue *);
  168. u2      RegisterClass(char *, int );
  169. u2      RegisterDouble(DoubleLiteralValue *);
  170. u2      RegisterFloat(FloatLiteralValue *);
  171. u2      RegisterInteger(IntLiteralValue *);
  172. u2      RegisterLong(LongLiteralValue *);
  173. u2      RegisterMethod(int);
  174. u2      RegisterString(Utf8LiteralValue *);
  175. u2      RegisterUtf8(Utf8LiteralValue *);
  176. u2      RegisterUtf8(char *, int);
  177.  
  178. void    AddLocalVariableTableEntry(u2,u2,u2,u2,u2); // make entry in local variable table
  179. void    SetInnerAttribute(TypeSymbol *); // make entry for InnerClasses attribute
  180. Synthetic_attribute * CreateSyntheticAttribute();
  181. Deprecated_attribute * CreateDeprecatedAttribute();
  182.  
  183. //
  184. // memory access: reference either
  185.         // constant (literal)
  186.         // name (includes local varable, or class variable, or field access)
  187.         // array
  188. #define LHS_LOCAL  0    // local variable
  189. #define LHS_ARRAY  1    // array (of any kind)
  190. #define LHS_FIELD  2    // instance variable
  191. #define LHS_STATIC 3    // class variable
  192. #define LHS_CLASS_METHOD 4  // access to private variable via class method call
  193. #define LHS_STATIC_METHOD 5 // access to private variable via static method call
  194.     // Methods in bc_expr.cpp        
  195. int     EmitExpression(AstExpression * ast);
  196. void    EmitArrayAccessLHS(AstArrayAccess *);
  197. int     EmitArrayAccessRHS(AstArrayAccess *);
  198. int     EmitArrayCreationExpression(AstArrayCreationExpression *);
  199. int     EmitAssignmentExpression(AstAssignmentExpression *, int);
  200. int     EmitBinaryExpression(AstBinaryExpression *);
  201. void    EmitBinaryOp(AstBinaryExpression *, int iop, int lop, int fop, int dop);
  202. int     EmitCastExpression(AstCastExpression *);
  203. void    EmitCast(TypeSymbol *, TypeSymbol *);
  204. int     EmitClassInstanceCreationExpression(AstClassInstanceCreationExpression *, int);
  205. int     EmitConditionalExpression(AstConditionalExpression *);
  206. int     EmitFieldAccess(AstFieldAccess *);
  207. void    EmitFieldAccessLHS(AstExpression *);
  208. void    EmitFieldAccessLHSBase(AstExpression *);
  209. int     EmitMethodInvocation(AstMethodInvocation *, int);
  210. void    EmitNewArray(int,TypeSymbol *);
  211. void    EmitCloneArray(AstMethodInvocation *);
  212. int     EmitPostUnaryExpression(AstPostUnaryExpression *,int);
  213. void    EmitPostUnaryExpressionArray(AstPostUnaryExpression *expression, int);
  214. void    EmitPostUnaryExpressionArrayCode(int, int, int, int, int, int, int, int, int);
  215. void    EmitPostUnaryExpressionField(int,AstPostUnaryExpression *expression, int);
  216. void    EmitPostUnaryExpressionSimple(int,AstPostUnaryExpression *, int);
  217. int     EmitPreUnaryExpression(AstPreUnaryExpression *,int);
  218. void    EmitPreUnaryIncrementExpression(AstPreUnaryExpression *expression, int);
  219. void    EmitPreUnaryIncrementExpressionArray(AstPreUnaryExpression *expression, int);
  220. void    EmitPreUnaryIncrementExpressionArrayCode(int, int, int, int, int, int, int,int,int);
  221. void    EmitPreUnaryIncrementExpressionField(int,AstPreUnaryExpression *expression, int);
  222. void    EmitPreUnaryIncrementExpressionSimple(int,AstPreUnaryExpression *expression, int);
  223. void    EmitThisInvocation(AstThisCall *);
  224. void    EmitSuperInvocation(AstSuperCall *);
  225. AstExpression * UnParenthesize(AstExpression *);
  226. void    ConcatenateString(AstBinaryExpression *);
  227. void    EmitStringBuffer();
  228. void    EmitCallStringToString();
  229. void    AppendString(AstExpression *);
  230. void    EmitStringAppendMethod(TypeSymbol *);
  231. void    GenerateAccessMethod(MethodSymbol *);
  232. int     GenerateFieldReference(VariableSymbol *);
  233. void    ChangeStack (int);
  234. void    ResolveAccess(AstExpression *, int);
  235. int     GenerateClassAccess(AstFieldAccess *);
  236. void    GenerateClassAccessMethod(MethodSymbol *);
  237.  
  238.     // Methods in bc_stmt.cpp
  239.  
  240. void    CompileClass(TypeSymbol *);
  241. //void    SetConstructorParameter(VariableSymbol *);
  242. void    CompileInterface(TypeSymbol *);
  243. void    CompileConstructor(AstConstructorDeclaration *, Tuple<AstVariableDeclarator *> &);
  244. #define METHOD_KIND_ORDINARY 0
  245. #define METHOD_KIND_CONSTRUCTOR 1
  246. #define METHOD_KIND_GENERATED_CONSTRUCTOR 2
  247. #define METHOD_KIND_INTERFACE 3
  248. #define METHOD_KIND_ACCESS 4
  249. #define METHOD_KIND_ACCESS_CLASS 5
  250. int     BeginMethod(int, MethodSymbol *);
  251. void    EndMethod(int,int, MethodSymbol *);
  252. void    DeclareField(VariableSymbol *);
  253. void    InitializeClassVariable(AstVariableDeclarator *);
  254. void    InitializeInstanceVariable(AstVariableDeclarator *);
  255. void    InitializeArray(TypeSymbol *,AstArrayInitializer *);
  256. void    DeclareLocalVariable(AstVariableDeclarator *);
  257. int     EmitStatement(AstStatement *);
  258. void    EmitReturnStatement(AstReturnStatement *);
  259. void    EmitSynchronizedStatement(AstSynchronizedStatement *);
  260. int     EmitBlockStatement(AstBlock *, int);
  261. void    EmitStatementExpression(AstExpression * ast);
  262. void    EmitSwitchStatement(AstSwitchStatement *);
  263. void    UpdateBlockInfo(BlockSymbol *);
  264. void    EmitTryStatement(AstTryStatement *);
  265. void    EmitBranch(unsigned int opc, Label &);
  266. void    EmitBranchIfExpression(AstExpression *, bool, Label &);
  267. void    GenerateReturn(TypeSymbol * type);
  268. void    CompleteCall(MethodSymbol *, int, int);
  269.  
  270. #ifdef TEST
  271. void PrintCode();
  272. #endif
  273. //void    ProcessMethodDeclaration(AstMethodDeclaration *method);
  274. void FinishCode(TypeSymbol *);
  275. void Reset(){
  276.         constant_pool.Reset();
  277.         fields.Reset();
  278.         methods.Reset();
  279.         attributes.Reset();
  280.         this_class = super_class = 0;
  281.     }
  282.  
  283. public:
  284.     ByteCode(TypeSymbol *);
  285.     
  286.     void PutOp(unsigned char opc);
  287.     void PutNop(int);
  288.     void PutI1(i1);
  289.     void PutI2(i2);
  290.     void PutU1(u1);
  291.     void PutU2(u2);
  292.     void PutU4(u4); 
  293. };
  294.  
  295. #endif
  296.